{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configuration for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = 'google.colab' in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt-get install -y xvfb python-opengl > /dev/null 2>&1\n",
    "    !pip install gym pyvirtualdisplay > /dev/null 2>&1\n",
    "    !pip install JSAnimation==0.1\n",
    "    !pip install pyglet==1.3.2\n",
    "    \n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(400, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 05. Soft Actor Critic (SAC)\n",
    "\n",
    "1. [T. Haarnoja et al., \"Soft Actor-Critic: Off-Policy Maximum Entropy Deep Reinforcement Learning with a Stochastic Actor.\" arXiv preprint arXiv:1801.01290, 2018.](https://arxiv.org/pdf/1801.01290.pdf)\n",
    "2. [T. Haarnoja et al., \"Soft Actor-Critic Algorithms and Applications.\" arXiv preprint arXiv:1812.05905, 2018.](https://arxiv.org/pdf/1812.05905.pdf)\n",
    "\n",
    "The main purpose of SAC is to maximize the actor's entropy while maximizing expected reward. We can expect both sample efficient learning and stability because maximizing entropy provides a substantial improvement in exploration and robustness.\n",
    "\n",
    "As an extension of standard RL's objective function $\\sum_t \\mathbb{E}_{(s_t, a_t) \\sim \\rho_\\pi} [r(s_t, a_t)]$, let's consider a more general maximum entropy objective which favors stochastic policies by augmenting the objective with the expected entropy of the policy over $\\rho_\\pi (s_t)$:\n",
    "\n",
    "$$J(\\pi) = \\sum_{t=0}^T \\mathbb{E}_{(s_t, a_t) \\sim \\rho_\\pi} [r(s_t, a_t) + \\alpha H(\\pi(\\cdot | s_t))].$$\n",
    "\n",
    "The temperature parameter $\\alpha$ determines the relative importance of the entropy term against the reward, and thus controls the stochasticity of the optimal policy. By this objective, the policy can explore more widely and capture multiple modes of near-optimal behavior. In conclusion, it considerably improves learning speed over other methods that optimize the conventional RL objective function.\n",
    "\n",
    "In the paper, the authors show that *Soft Policy Iteration* guarantees convergence based on a tabular setting (4.1), and they extend it to a practical approximation for large continuous domains (4.2). Firstly, the soft value function is trained to minimize the squared residual error:\n",
    "\n",
    "$$J_V (\\psi) = \\mathbb{E}_{s_t \\sim D} \\big[ \\frac{1}{2}(v_\\psi (s_t) - \\mathbb{E}_{a_t \\sim \\pi_\\phi} [Q_\\theta(s_t, a_t) - \\log_{\\pi_\\phi}(a_t | s_t)])^2 \\big],$$\n",
    "\n",
    "where $D$ is the distribution of previously sampled states and actions, or a replay buffer. Second, the soft Q-function parameters can be trained to minimize the soft Bellman residual:\n",
    "\n",
    "$$J_Q (\\theta) = \\mathbb{E}_{(s_t, a_t) \\sim D} \\big[ \\frac{1}{2} \\big( Q_\\theta(s_t, a_t) - \\hat{Q}(s_t, a_t) \\big)^2 \\big],$$\n",
    "\n",
    "with $\\hat{Q}(s_t, a_t) = r(s_t, a_t) + \\gamma \\mathbb{E}_{s_{t+1} \\sim \\rho} [V_{\\tilde{\\psi}} (s_{t+1})].$\n",
    "\n",
    "Finally, the policy paramameters can be learned by directly minimizing the following expected KL-divergence:\n",
    "\n",
    "$$J_\\pi(\\phi) = \\mathbb{E}_{s_t \\sim D} \\big[ D_{KL} \\big( \\pi_{\\phi} (\\cdot | s_t) \\| \\frac{\\exp(Q_{\\theta}(s_t, \\cdot))}{Z_\\theta(s_t)} \\big) \\big].$$\n",
    "\n",
    "We can rewirte the objective as\n",
    "\n",
    "$$J_\\pi(\\phi) = \\mathbb{E}_{s_t \\sim D, \\epsilon_t \\sim N} [ \\log_{\\pi_\\phi}(f_\\phi(\\epsilon_t ; s_t) | s_t) - Q_\\theta (s_t, f_\\phi (\\epsilon_t ; s_t))],$$\n",
    "\n",
    "where $\\pi_\\phi$ is defined implicitly in terms of $f_\\phi$, and the partition function is independent of $\\phi$ and can thus be omitted.\n",
    "\n",
    "One thing to note is that the authors suggest to use two Q-functions to mitigate positive bias in the policy improvement step that is known to degrade performance of value based methods. In particular, we parameterize two Q-functions, with parameters $\\theta_i$, and train them independently to optimize $J_Q(\\theta_i)$. We then use the minimum of the Q-functions for the value gradient and policy gradient. Two Q-functions can significantly speed up training, especially on harder tasks.\n",
    "\n",
    "### Can we do better?\n",
    "\n",
    "In Soft Actor Critic paper, the experiment of reward scale shows that SAC's performance quite varies depending on reward scaling. In the follow-up paper [2], the authors assume that the temperature parameter $\\alpha$ needs to be adjusted depending on the magnitude of the reward, and they define the soft policy optimization as a constrained problem.\n",
    "\n",
    "$$\\max_{\\pi_{0:T}} \\mathbb{E}_{\\rho_\\pi} \\big[ \\sum_{t=0}^T r(s_t, a_t) \\big] \\text{ s.t. } \\mathbb{E}_{(s_t, a_t) \\sim \\rho_\\pi} [-\\log(\\pi_t(a_t|s_t))] \\ge H \\text{ for all } t,$$\n",
    "\n",
    "where $H$ is a desired minimum expected entropy. This constrained maximization becomes the following dual problem.\n",
    "\n",
    "$$\\min_{a_T \\ge 0} \\max_{\\pi_T} \\mathbb{E} [r(s_T, a_T) - \\alpha_T \\log \\pi(a_t|s_t)] - \\alpha_T H,$$\n",
    "\n",
    "where $\\alpha_T$ is the dual variable. Furthermore, it can be rewrited as a optimization problem with regards to $\\alpha$.\n",
    "\n",
    "$$J(\\alpha) = \\mathbb{E}_{a_t \\sim \\pi_t} [-\\alpha \\log \\pi_t (a_t | s_t) - \\alpha H].$$\n",
    "\n",
    "By optimizing this dual problem, we can adjust the dual variable $\\alpha$, which plays the role of the temperature."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "from typing import Dict, List, Tuple\n",
    "\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output\n",
    "from torch.distributions import Normal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "if torch.backends.cudnn.enabled:\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "\n",
    "seed = 777\n",
    "torch.manual_seed(seed)\n",
    "np.random.seed(seed)\n",
    "random.seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay buffer\n",
    "Typically, people implement replay buffers with one of the following three data structures:\n",
    "\n",
    "- collections.deque\n",
    "- list\n",
    "- numpy.ndarray\n",
    "\n",
    "**deque** is very easy to handle once you initialize its maximum length (e.g. deque(maxlen=buffer_size)). However, the indexing operation of deque gets terribly slow as it grows up because it is [internally doubly linked list](https://wiki.python.org/moin/TimeComplexity#collections.deque). On the other hands, **list** is an array, so it is relatively faster than deque when you sample batches at every step. Its amortized cost of Get item is [O(1)](https://wiki.python.org/moin/TimeComplexity#list).\n",
    "\n",
    "Last but not least, let's see **numpy.ndarray**. numpy.ndarray is even faster than list due to the fact that it is [a homogeneous array of fixed-size items](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html#numpy.ndarray), so you can get the benefits of [locality of reference](https://en.wikipedia.org/wiki/Locality_of_reference), . Whereas list is an array of pointers to objects, even when all of them are of the same type.\n",
    "\n",
    "Here, we are going to implement a replay buffer using numpy.ndarray.\n",
    "\n",
    "Reference: \n",
    "- [OpenAI spinning-up](https://github.com/openai/spinningup/blob/master/spinup/algos/sac/sac.py#L10)\n",
    "- [rainbow-is-all-you-need](https://render.githubusercontent.com/view/ipynb?commit=032d11277cf2436853478a69ca5a4aba03202598&enc_url=68747470733a2f2f7261772e67697468756275736572636f6e74656e742e636f6d2f437572742d5061726b2f7261696e626f772d69732d616c6c2d796f752d6e6565642f303332643131323737636632343336383533343738613639636135613461626130333230323539382f30312e64716e2e6970796e62&nwo=Curt-Park%2Frainbow-is-all-you-need&path=01.dqn.ipynb&repository_id=191133946&repository_type=Repository#Replay-buffer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(self, obs_dim: int, size: int, batch_size: int = 32):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "\n",
    "    def store(self,\n",
    "        obs: np.ndarray,\n",
    "        act: np.ndarray, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool,\n",
    "    ):\n",
    "        \"\"\"Store the transition in buffer.\"\"\"\n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        \"\"\"Randomly sample a batch of experiences from memory.\"\"\"\n",
    "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
    "        return dict(obs=self.obs_buf[idxs],\n",
    "                    next_obs=self.next_obs_buf[idxs],\n",
    "                    acts=self.acts_buf[idxs],\n",
    "                    rews=self.rews_buf[idxs],\n",
    "                    done=self.done_buf[idxs])\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network\n",
    "We are going to use three different networks for policy, Q-function, and V-function. We use two Q-functions to mitigate positive bias and softly update V-function for stable learning. One interesting thing is that the policy network works as Tanh Normal distribution which enforces action bounds. (The details are descibed in Appendix C of [2].)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def init_layer_uniform(layer: nn.Linear, init_w: float = 3e-3) -> nn.Linear:\n",
    "    \"\"\"Init uniform parameters on the single layer.\"\"\"\n",
    "    layer.weight.data.uniform_(-init_w, init_w)\n",
    "    layer.bias.data.uniform_(-init_w, init_w)\n",
    "\n",
    "    return layer\n",
    "\n",
    "\n",
    "class Actor(nn.Module):\n",
    "    def __init__(\n",
    "        self, \n",
    "        in_dim: int, \n",
    "        out_dim: int,\n",
    "        log_std_min: float = -20,\n",
    "        log_std_max: float = 2,\n",
    "    ):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        super(Actor, self).__init__()\n",
    "        \n",
    "        # set the log std range\n",
    "        self.log_std_min = log_std_min\n",
    "        self.log_std_max = log_std_max\n",
    "        \n",
    "        # set the hidden layers\n",
    "        self.hidden1 = nn.Linear(in_dim, 128)\n",
    "        self.hidden2 = nn.Linear(128, 128)\n",
    "        \n",
    "        # set log_std layer\n",
    "        self.log_std_layer = nn.Linear(128, out_dim)\n",
    "        self.log_std_layer = init_layer_uniform(self.log_std_layer)\n",
    "\n",
    "        # set mean layer\n",
    "        self.mu_layer = nn.Linear(128, out_dim)\n",
    "        self.mu_layer = init_layer_uniform(self.mu_layer)\n",
    "\n",
    "    def forward(self, state: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        x = F.relu(self.hidden1(state))\n",
    "        x = F.relu(self.hidden2(x))\n",
    "        \n",
    "        # get mean\n",
    "        mu = self.mu_layer(x).tanh()\n",
    "        \n",
    "        # get std\n",
    "        log_std = self.log_std_layer(x).tanh()\n",
    "        log_std = self.log_std_min + 0.5 * (\n",
    "            self.log_std_max - self.log_std_min\n",
    "        ) * (log_std + 1)\n",
    "        std = torch.exp(log_std)\n",
    "        \n",
    "        # sample actions\n",
    "        dist = Normal(mu, std)\n",
    "        z = dist.rsample()\n",
    "        \n",
    "        # normalize action and log_prob\n",
    "        # see appendix C of [2]\n",
    "        action = z.tanh()\n",
    "        log_prob = dist.log_prob(z) - torch.log(1 - action.pow(2) + 1e-7)\n",
    "        log_prob = log_prob.sum(-1, keepdim=True)\n",
    "        \n",
    "        return action, log_prob\n",
    "    \n",
    "    \n",
    "class CriticQ(nn.Module):\n",
    "    def __init__(self, in_dim: int):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        super(CriticQ, self).__init__()\n",
    "        \n",
    "        self.hidden1 = nn.Linear(in_dim, 128)\n",
    "        self.hidden2 = nn.Linear(128, 128)\n",
    "        self.out = nn.Linear(128, 1)\n",
    "        self.out = init_layer_uniform(self.out)\n",
    "\n",
    "    def forward(\n",
    "        self, state: torch.Tensor, action: torch.Tensor\n",
    "    ) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        x = torch.cat((state, action), dim=-1)\n",
    "        x = F.relu(self.hidden1(x))\n",
    "        x = F.relu(self.hidden2(x))\n",
    "        value = self.out(x)\n",
    "        \n",
    "        return value\n",
    "    \n",
    "    \n",
    "class CriticV(nn.Module):\n",
    "    def __init__(self, in_dim: int):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        super(CriticV, self).__init__()\n",
    "        \n",
    "        self.hidden1 = nn.Linear(in_dim, 128)\n",
    "        self.hidden2 = nn.Linear(128, 128)\n",
    "        self.out = nn.Linear(128, 1)\n",
    "        self.out = init_layer_uniform(self.out)\n",
    "\n",
    "    def forward(self, state: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        x = F.relu(self.hidden1(state))\n",
    "        x = F.relu(self.hidden2(x))\n",
    "        value = self.out(x)\n",
    "        \n",
    "        return value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SAC Agent\n",
    "Here is a summary of SACAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "|---               |---                                                  |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|\\_target_soft_update| soft update from the local model to the target model.|\n",
    "|\\_plot              | plot the training progresses.                        |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SACAgent:\n",
    "    \"\"\"SAC agent interacting with environment.\n",
    "    \n",
    "    Attrtibutes:\n",
    "        actor (nn.Module): actor model to select actions\n",
    "        actor_optimizer (Optimizer): optimizer for training actor\n",
    "        vf (nn.Module): critic model to predict state values\n",
    "        vf_target (nn.Module): target critic model to predict state values\n",
    "        vf_optimizer (Optimizer): optimizer for training vf\n",
    "        qf_1 (nn.Module): critic model to predict state-action values\n",
    "        qf_2 (nn.Module): critic model to predict state-action values\n",
    "        qf_1_optimizer (Optimizer): optimizer for training qf_1\n",
    "        qf_2_optimizer (Optimizer): optimizer for training qf_2\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        memory (ReplayBuffer): replay memory\n",
    "        batch_size (int): batch size for sampling\n",
    "        gamma (float): discount factor\n",
    "        tau (float): parameter for soft target update\n",
    "        initial_random_steps (int): initial random action steps\n",
    "        policy_update_freq (int): policy update frequency\n",
    "        device (torch.device): cpu / gpu\n",
    "        target_entropy (int): desired entropy used for the inequality constraint\n",
    "        log_alpha (torch.Tensor): weight for entropy\n",
    "        alpha_optimizer (Optimizer): optimizer for alpha\n",
    "        transition (list): temporory storage for the recent transition\n",
    "        total_step (int): total step numbers\n",
    "        is_test (bool): flag to show the current mode (train / test)\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(\n",
    "        self,\n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        gamma: float = 0.99,\n",
    "        tau: float = 5e-3,\n",
    "        initial_random_steps: int = int(1e4),\n",
    "        policy_update_freq: int = 2,\n",
    "    ):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.shape[0]\n",
    "\n",
    "        self.env = env\n",
    "        self.memory = ReplayBuffer(obs_dim, memory_size, batch_size)\n",
    "        self.batch_size = batch_size\n",
    "        self.gamma = gamma\n",
    "        self.tau = tau\n",
    "        self.initial_random_steps = initial_random_steps\n",
    "        self.policy_update_freq = policy_update_freq\n",
    "\n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\n",
    "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        )\n",
    "        print(self.device)\n",
    "        \n",
    "        # automatic entropy tuning\n",
    "        self.target_entropy = -np.prod((action_dim,)).item()  # heuristic\n",
    "        self.log_alpha = torch.zeros(1, requires_grad=True, device=self.device)\n",
    "        self.alpha_optimizer = optim.Adam([self.log_alpha], lr=3e-4)\n",
    "\n",
    "        # actor\n",
    "        self.actor = Actor(obs_dim, action_dim).to(self.device)\n",
    "        \n",
    "        # v function\n",
    "        self.vf = CriticV(obs_dim).to(self.device)\n",
    "        self.vf_target = CriticV(obs_dim).to(self.device)\n",
    "        self.vf_target.load_state_dict(self.vf.state_dict())\n",
    "        \n",
    "        # q function\n",
    "        self.qf_1 = CriticQ(obs_dim + action_dim).to(self.device)\n",
    "        self.qf_2 = CriticQ(obs_dim + action_dim).to(self.device)\n",
    "\n",
    "        # optimizers\n",
    "        self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=3e-4)\n",
    "        self.vf_optimizer = optim.Adam(self.vf.parameters(), lr=3e-4)\n",
    "        self.qf_1_optimizer = optim.Adam(self.qf_1.parameters(), lr=3e-4)\n",
    "        self.qf_2_optimizer = optim.Adam(self.qf_2.parameters(), lr=3e-4)\n",
    "        \n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "        \n",
    "        # total steps count\n",
    "        self.total_step = 0\n",
    "\n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "    \n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # if initial random action should be conducted\n",
    "        if self.total_step < self.initial_random_steps and not self.is_test:\n",
    "            selected_action = self.env.action_space.sample()\n",
    "        else:\n",
    "            selected_action = self.actor(\n",
    "                torch.FloatTensor(state).to(self.device)\n",
    "            )[0].detach().cpu().numpy()\n",
    "            \n",
    "        self.transition = [state, selected_action]\n",
    "        \n",
    "        return selected_action\n",
    "    \n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, float, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, done, _ = self.env.step(action)\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            self.memory.store(*self.transition)\n",
    "    \n",
    "        return next_state, reward, done\n",
    "    \n",
    "    def update_model(self) -> Tuple[torch.Tensor, ...]:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "        \n",
    "        samples = self.memory.sample_batch()\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.FloatTensor(samples[\"acts\"].reshape(-1, 1)).to(device)\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "        new_action, log_prob = self.actor(state)\n",
    "        \n",
    "        # train alpha (dual problem)\n",
    "        alpha_loss = (\n",
    "            -self.log_alpha.exp() * (log_prob + self.target_entropy).detach()\n",
    "        ).mean()\n",
    "\n",
    "        self.alpha_optimizer.zero_grad()\n",
    "        alpha_loss.backward()\n",
    "        self.alpha_optimizer.step()\n",
    "        \n",
    "        alpha = self.log_alpha.exp()  # used for the actor loss calculation\n",
    "        \n",
    "        # q function loss\n",
    "        mask = 1 - done\n",
    "        q_1_pred = self.qf_1(state, action)\n",
    "        q_2_pred = self.qf_2(state, action)\n",
    "        v_target = self.vf_target(next_state)\n",
    "        q_target = reward + self.gamma * v_target * mask\n",
    "        qf_1_loss = F.mse_loss(q_1_pred, q_target.detach())\n",
    "        qf_2_loss = F.mse_loss(q_2_pred, q_target.detach())\n",
    "        \n",
    "        # v function loss\n",
    "        v_pred = self.vf(state)\n",
    "        q_pred = torch.min(\n",
    "            self.qf_1(state, new_action), self.qf_2(state, new_action)\n",
    "        )\n",
    "        v_target = q_pred - alpha * log_prob\n",
    "        vf_loss = F.mse_loss(v_pred, v_target.detach())\n",
    "        \n",
    "        # train Q functions\n",
    "        self.qf_1_optimizer.zero_grad()\n",
    "        qf_1_loss.backward()\n",
    "        self.qf_1_optimizer.step()\n",
    "\n",
    "        self.qf_2_optimizer.zero_grad()\n",
    "        qf_2_loss.backward()\n",
    "        self.qf_2_optimizer.step()\n",
    "        \n",
    "        qf_loss = qf_1_loss + qf_2_loss\n",
    "\n",
    "        # train V function\n",
    "        self.vf_optimizer.zero_grad()\n",
    "        vf_loss.backward()\n",
    "        self.vf_optimizer.step()\n",
    "        \n",
    "        if self.total_step % self.policy_update_freq == 0:\n",
    "            # actor loss\n",
    "            advantage = q_pred - v_pred.detach()\n",
    "            actor_loss = (alpha * log_prob - advantage).mean()\n",
    "            \n",
    "            # train actor\n",
    "            self.actor_optimizer.zero_grad()\n",
    "            actor_loss.backward()\n",
    "            self.actor_optimizer.step()\n",
    "        \n",
    "            # target update (vf)\n",
    "            self._target_soft_update()\n",
    "        else:\n",
    "            actor_loss = torch.zeros(1)\n",
    "        \n",
    "        return actor_loss.data, qf_loss.data, vf_loss.data, alpha_loss.data\n",
    "    \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        actor_losses, qf_losses, vf_losses, alpha_losses = [], [], [], []\n",
    "        scores = []\n",
    "        score = 0\n",
    "        \n",
    "        for self.total_step in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "            # if episode ends\n",
    "            if done:\n",
    "                state = env.reset()\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if (\n",
    "                len(self.memory) >= self.batch_size \n",
    "                and self.total_step > self.initial_random_steps\n",
    "            ):\n",
    "                losses = self.update_model()\n",
    "                actor_losses.append(losses[0])\n",
    "                qf_losses.append(losses[1])\n",
    "                vf_losses.append(losses[2])\n",
    "                alpha_losses.append(losses[3])\n",
    "            \n",
    "            # plotting\n",
    "            if self.total_step % plotting_interval == 0:\n",
    "                self._plot(\n",
    "                    self.total_step,\n",
    "                    scores, \n",
    "                    actor_losses, \n",
    "                    qf_losses, \n",
    "                    vf_losses, \n",
    "                    alpha_losses\n",
    "                )\n",
    "                \n",
    "        self.env.close()\n",
    "        \n",
    "    def test(self):\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        frames = []\n",
    "        while not done:\n",
    "            frames.append(self.env.render(mode=\"rgb_array\"))\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "        \n",
    "        return frames\n",
    "    \n",
    "    def _target_soft_update(self):\n",
    "        \"\"\"Soft-update: target = tau*local + (1-tau)*target.\"\"\"\n",
    "        tau = self.tau\n",
    "        \n",
    "        for t_param, l_param in zip(\n",
    "            self.vf_target.parameters(), self.vf.parameters()\n",
    "        ):\n",
    "            t_param.data.copy_(tau * l_param.data + (1.0 - tau) * t_param.data)\n",
    "    \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        actor_losses: List[float],\n",
    "        qf_losses: List[float],\n",
    "        vf_losses: List[float],\n",
    "        alpha_losses: List[float],\n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        def subplot(loc: int, title: str, values: List[float]):\n",
    "            plt.subplot(loc)\n",
    "            plt.title(title)\n",
    "            plt.plot(values)\n",
    "\n",
    "        subplot_params = [\n",
    "            (151, f\"frame {frame_idx}. score: {np.mean(scores[-10:])}\", scores),\n",
    "            (152, \"actor_loss\", actor_losses),\n",
    "            (153, \"qf_loss\", qf_losses),\n",
    "            (154, \"vf_loss\", vf_losses),\n",
    "            (155, \"alpha_loss\", alpha_losses),\n",
    "        ]\n",
    "        \n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(30, 5))\n",
    "        for loc, title, values in subplot_params:\n",
    "            subplot(loc, title, values)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "*ActionNormalizer* is an action wrapper class to normalize the action values ranged in (-1. 1). Thanks to this class, we can make the agent simply select action values within the zero centered range (-1, 1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ActionNormalizer(gym.ActionWrapper):\n",
    "    \"\"\"Rescale and relocate the actions.\"\"\"\n",
    "\n",
    "    def action(self, action: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Change the range (-1, 1) to (low, high).\"\"\"\n",
    "        low = self.action_space.low\n",
    "        high = self.action_space.high\n",
    "\n",
    "        scale_factor = (high - low) / 2\n",
    "        reloc_factor = high - scale_factor\n",
    "\n",
    "        action = action * scale_factor + reloc_factor\n",
    "        action = np.clip(action, low, high)\n",
    "\n",
    "        return action\n",
    "\n",
    "    def reverse_action(self, action: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Change the range (low, high) to (-1, 1).\"\"\"\n",
    "        low = self.action_space.low\n",
    "        high = self.action_space.high\n",
    "\n",
    "        scale_factor = (high - low) / 2\n",
    "        reloc_factor = high - scale_factor\n",
    "\n",
    "        action = (action - reloc_factor) / scale_factor\n",
    "        action = np.clip(action, -1.0, 1.0)\n",
    "\n",
    "        return action"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see [the code](https://github.com/openai/gym/blob/master/gym/envs/classic_control/pendulum.py) and [configurations](https://github.com/openai/gym/blob/cedecb35e3428985fd4efad738befeb75b9077f1/gym/envs/__init__.py#L81) of Pendulum-v0 from OpenAI's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# environment\n",
    "env_id = \"Pendulum-v0\"\n",
    "env = gym.make(env_id)\n",
    "env = ActionNormalizer(env)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 50000\n",
    "memory_size = 100000\n",
    "batch_size = 128\n",
    "initial_random_steps = 10000\n",
    "\n",
    "agent = SACAgent(\n",
    "    env, memory_size, batch_size, initial_random_steps=initial_random_steps\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2160x360 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score:  -340.407760548057\n"
     ]
    }
   ],
   "source": [
    "frames = agent.test()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Define the Animation class */\n",
       "  function Animation(frames, img_id, slider_id, interval, loop_select_id){\n",
       "    this.img_id = img_id;\n",
       "    this.slider_id = slider_id;\n",
       "    this.loop_select_id = loop_select_id;\n",
       "    this.interval = interval;\n",
       "    this.current_frame = 0;\n",
       "    this.direction = 0;\n",
       "    this.timer = null;\n",
       "    this.frames = new Array(frames.length);\n",
       "\n",
       "    for (var i=0; i<frames.length; i++)\n",
       "    {\n",
       "     this.frames[i] = new Image();\n",
       "     this.frames[i].src = frames[i];\n",
       "    }\n",
       "    document.getElementById(this.slider_id).max = this.frames.length - 1;\n",
       "    this.set_frame(this.current_frame);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.get_loop_state = function(){\n",
       "    var button_group = document[this.loop_select_id].state;\n",
       "    for (var i = 0; i < button_group.length; i++) {\n",
       "        var button = button_group[i];\n",
       "        if (button.checked) {\n",
       "            return button.value;\n",
       "        }\n",
       "    }\n",
       "    return undefined;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.set_frame = function(frame){\n",
       "    this.current_frame = frame;\n",
       "    document.getElementById(this.img_id).src = this.frames[this.current_frame].src;\n",
       "    document.getElementById(this.slider_id).value = this.current_frame;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.next_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.min(this.frames.length - 1, this.current_frame + 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.previous_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.max(0, this.current_frame - 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.first_frame = function()\n",
       "  {\n",
       "    this.set_frame(0);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.last_frame = function()\n",
       "  {\n",
       "    this.set_frame(this.frames.length - 1);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.slower = function()\n",
       "  {\n",
       "    this.interval /= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.faster = function()\n",
       "  {\n",
       "    this.interval *= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_forward = function()\n",
       "  {\n",
       "    this.current_frame += 1;\n",
       "    if(this.current_frame < this.frames.length){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.first_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.last_frame();\n",
       "        this.reverse_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.last_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_reverse = function()\n",
       "  {\n",
       "    this.current_frame -= 1;\n",
       "    if(this.current_frame >= 0){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.last_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.first_frame();\n",
       "        this.play_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.first_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.pause_animation = function()\n",
       "  {\n",
       "    this.direction = 0;\n",
       "    if (this.timer){\n",
       "      clearInterval(this.timer);\n",
       "      this.timer = null;\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.play_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = 1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_forward();}, this.interval);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.reverse_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = -1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_reverse();}, this.interval);\n",
       "  }\n",
       "</script>\n",
       "\n",
       "<div class=\"animation\" align=\"center\">\n",
       "    <img id=\"_anim_imgFXIWVIUEQZACUCYW\">\n",
       "    <br>\n",
       "    <input id=\"_anim_sliderFXIWVIUEQZACUCYW\" type=\"range\" style=\"width:350px\" name=\"points\" min=\"0\" max=\"1\" step=\"1\" value=\"0\" onchange=\"animFXIWVIUEQZACUCYW.set_frame(parseInt(this.value));\"></input>\n",
       "    <br>\n",
       "    <button onclick=\"animFXIWVIUEQZACUCYW.slower()\">&#8211;</button>\n",
       "    <button onclick=\"animFXIWVIUEQZACUCYW.first_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animFXIWVIUEQZACUCYW.previous_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animFXIWVIUEQZACUCYW.reverse_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animFXIWVIUEQZACUCYW.pause_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animFXIWVIUEQZACUCYW.play_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animFXIWVIUEQZACUCYW.next_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animFXIWVIUEQZACUCYW.last_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animFXIWVIUEQZACUCYW.faster()\">+</button>\n",
       "  <form action=\"#n\" name=\"_anim_loop_selectFXIWVIUEQZACUCYW\" class=\"anim_control\">\n",
       "    <input type=\"radio\" name=\"state\" value=\"once\" > Once </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"loop\" checked> Loop </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"reflect\" > Reflect </input>\n",
       "  </form>\n",
       "</div>\n",
       "\n",
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Instantiate the Animation class. */\n",
       "  /* The IDs given should match those used in the template above. */\n",
       "  (function() {\n",
       "    var img_id = \"_anim_imgFXIWVIUEQZACUCYW\";\n",
       "    var slider_id = \"_anim_sliderFXIWVIUEQZACUCYW\";\n",
       "    var loop_select_id = \"_anim_loop_selectFXIWVIUEQZACUCYW\";\n",
       "    var frames = new Array(0);\n",
       "    \n",
       "  frames[0] = \"\"\n",
       "  frames[1] = \"\"\n",
       "  frames[2] = \"\"\n",
       "  frames[3] = \"\"\n",
       "  frames[4] = \"\"\n",
       "  frames[5] = \"\"\n",
       "  frames[6] = \"\"\n",
       "  frames[7] = \"\"\n",
       "  frames[8] = \"\"\n",
       "  frames[9] = \"\"\n",
       "  frames[10] = \"\"\n",
       "  frames[11] = \"\"\n",
       "  frames[12] = \"\"\n",
       "  frames[13] = \"\"\n",
       "  frames[14] = \"\"\n",
       "  frames[15] = \"\"\n",
       "  frames[16] = \"\"\n",
       "  frames[17] = \"\"\n",
       "  frames[18] = \"\"\n",
       "  frames[19] = \"\"\n",
       "  frames[20] = \"\"\n",
       "  frames[21] = \"\"\n",
       "  frames[22] = \"\"\n",
       "  frames[23] = \"\"\n",
       "  frames[24] = \"\"\n",
       "  frames[25] = \"\"\n",
       "  frames[26] = \"\"\n",
       "  frames[27] = \"\"\n",
       "  frames[28] = \"\"\n",
       "  frames[29] = \"\"\n",
       "  frames[30] = \"\"\n",
       "  frames[31] = \"\"\n",
       "  frames[32] = \"\"\n",
       "  frames[33] = \"\"\n",
       "  frames[34] = \"\"\n",
       "  frames[35] = \"\"\n",
       "  frames[36] = \"\"\n",
       "  frames[37] = \"\"\n",
       "  frames[38] = \"\"\n",
       "  frames[39] = \"\"\n",
       "  frames[40] = \"\"\n",
       "  frames[41] = \"\"\n",
       "  frames[42] = \"\"\n",
       "  frames[43] = \"\"\n",
       "  frames[44] = \"\"\n",
       "  frames[45] = \"\"\n",
       "  frames[46] = \"\"\n",
       "  frames[47] = \"\"\n",
       "  frames[48] = \"\"\n",
       "  frames[49] = \"\"\n",
       "  frames[50] = \"\"\n",
       "  frames[51] = \"\"\n",
       "  frames[52] = \"\"\n",
       "  frames[53] = \"\"\n",
       "  frames[54] = \"\"\n",
       "  frames[55] = \"\"\n",
       "  frames[56] = \"\"\n",
       "  frames[57] = \"\"\n",
       "  frames[58] = \"\"\n",
       "  frames[59] = \"\"\n",
       "  frames[60] = \"\"\n",
       "  frames[61] = \"\"\n",
       "  frames[62] = \"\"\n",
       "  frames[63] = \"\"\n",
       "  frames[64] = \"\"\n",
       "  frames[65] = \"\"\n",
       "  frames[66] = \"\"\n",
       "  frames[67] = \"\"\n",
       "  frames[68] = \"\"\n",
       "  frames[69] = \"\"\n",
       "  frames[70] = \"\"\n",
       "  frames[71] = \"\"\n",
       "  frames[72] = \"\"\n",
       "  frames[73] = \"\"\n",
       "  frames[74] = \"\"\n",
       "  frames[75] = \"\"\n",
       "  frames[76] = \"\"\n",
       "  frames[77] = \"\"\n",
       "  frames[78] = \"\"\n",
       "  frames[79] = \"\"\n",
       "  frames[80] = \"\"\n",
       "  frames[81] = \"\"\n",
       "  frames[82] = \"\"\n",
       "  frames[83] = \"\"\n",
       "  frames[84] = \"\"\n",
       "  frames[85] = \"\"\n",
       "  frames[86] = \"\"\n",
       "  frames[87] = \"\"\n",
       "  frames[88] = \"\"\n",
       "  frames[89] = \"\"\n",
       "  frames[90] = \"\"\n",
       "  frames[91] = \"\"\n",
       "  frames[92] = \"\"\n",
       "  frames[93] = \"\"\n",
       "  frames[94] = \"\"\n",
       "  frames[95] = \"\"\n",
       "  frames[96] = \"\"\n",
       "  frames[97] = \"\"\n",
       "  frames[98] = \"\"\n",
       "  frames[99] = \"\"\n",
       "  frames[100] = \"\"\n",
       "  frames[101] = \"\"\n",
       "  frames[102] = \"\"\n",
       "  frames[103] = \"\"\n",
       "  frames[104] = \"\"\n",
       "  frames[105] = \"\"\n",
       "  frames[106] = \"\"\n",
       "  frames[107] = \"\"\n",
       "  frames[108] = \"\"\n",
       "  frames[109] = \"\"\n",
       "  frames[110] = \"\"\n",
       "  frames[111] = \"\"\n",
       "  frames[112] = \"\"\n",
       "  frames[113] = \"\"\n",
       "  frames[114] = \"\"\n",
       "  frames[115] = \"\"\n",
       "  frames[116] = \"\"\n",
       "  frames[117] = \"\"\n",
       "  frames[118] = \"\"\n",
       "  frames[119] = \"\"\n",
       "  frames[120] = \"\"\n",
       "  frames[121] = \"\"\n",
       "  frames[122] = \"\"\n",
       "  frames[123] = \"\"\n",
       "  frames[124] = \"\"\n",
       "  frames[125] = \"\"\n",
       "  frames[126] = \"\"\n",
       "  frames[127] = \"\"\n",
       "  frames[128] = \"\"\n",
       "  frames[129] = \"\"\n",
       "  frames[130] = \"\"\n",
       "  frames[131] = \"\"\n",
       "  frames[132] = \"\"\n",
       "  frames[133] = \"\"\n",
       "  frames[134] = \"\"\n",
       "  frames[135] = \"\"\n",
       "  frames[136] = \"\"\n",
       "  frames[137] = \"\"\n",
       "  frames[138] = \"\"\n",
       "  frames[139] = \"\"\n",
       "  frames[140] = \"\"\n",
       "  frames[141] = \"\"\n",
       "  frames[142] = \"\"\n",
       "  frames[143] = \"\"\n",
       "  frames[144] = \"\"\n",
       "  frames[145] = \"\"\n",
       "  frames[146] = \"\"\n",
       "  frames[147] = \"\"\n",
       "  frames[148] = \"\"\n",
       "  frames[149] = \"\"\n",
       "  frames[150] = \"\"\n",
       "  frames[151] = \"\"\n",
       "  frames[152] = \"\"\n",
       "  frames[153] = \"\"\n",
       "  frames[154] = \"\"\n",
       "  frames[155] = \"\"\n",
       "  frames[156] = \"\"\n",
       "  frames[157] = \"\"\n",
       "  frames[158] = \"\"\n",
       "  frames[159] = \"\"\n",
       "  frames[160] = \"\"\n",
       "  frames[161] = \"\"\n",
       "  frames[162] = \"\"\n",
       "  frames[163] = \"\"\n",
       "  frames[164] = \"\"\n",
       "  frames[165] = \"\"\n",
       "  frames[166] = \"\"\n",
       "  frames[167] = \"\"\n",
       "  frames[168] = \"\"\n",
       "  frames[169] = \"\"\n",
       "  frames[170] = \"\"\n",
       "  frames[171] = \"\"\n",
       "  frames[172] = \"\"\n",
       "  frames[173] = \"\"\n",
       "  frames[174] = \"\"\n",
       "  frames[175] = \"\"\n",
       "  frames[176] = \"\"\n",
       "  frames[177] = \"\"\n",
       "  frames[178] = \"\"\n",
       "  frames[179] = \"\"\n",
       "  frames[180] = \"\"\n",
       "  frames[181] = \"\"\n",
       "  frames[182] = \"\"\n",
       "  frames[183] = \"\"\n",
       "  frames[184] = \"\"\n",
       "  frames[185] = \"\"\n",
       "  frames[186] = \"\"\n",
       "  frames[187] = \"\"\n",
       "  frames[188] = \"\"\n",
       "  frames[189] = \"\"\n",
       "  frames[190] = \"\"\n",
       "  frames[191] = \"\"\n",
       "  frames[192] = \"\"\n",
       "  frames[193] = \"\"\n",
       "  frames[194] = \"\"\n",
       "  frames[195] = \"\"\n",
       "  frames[196] = \"\"\n",
       "  frames[197] = \"\"\n",
       "  frames[198] = \"\"\n",
       "  frames[199] = \"\"\n",
       "\n",
       "\n",
       "    /* set a timeout to make sure all the above elements are created before\n",
       "       the object is initialized. */\n",
       "    setTimeout(function() {\n",
       "        animFXIWVIUEQZACUCYW = new Animation(frames, img_id, slider_id, 50, loop_select_id);\n",
       "    }, 0);\n",
       "  })()\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Imports specifically so we can render outputs in Colab.\n",
    "from matplotlib import animation\n",
    "from JSAnimation.IPython_display import display_animation\n",
    "from IPython.display import display\n",
    "\n",
    "\n",
    "def display_frames_as_gif(frames):\n",
    "    \"\"\"Displays a list of frames as a gif, with controls.\"\"\"\n",
    "    patch = plt.imshow(frames[0])\n",
    "    plt.axis('off')\n",
    "\n",
    "    def animate(i):\n",
    "        patch.set_data(frames[i])\n",
    "\n",
    "    anim = animation.FuncAnimation(\n",
    "        plt.gcf(), animate, frames = len(frames), interval=50\n",
    "    )\n",
    "    display(display_animation(anim, default_mode='loop'))\n",
    "    \n",
    "        \n",
    "# display \n",
    "display_frames_as_gif(frames)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
